// 错题集页面
const app = getApp();

Page({
  data: {
    // 用户登录状态
    isLoggedIn: false,
    userInfo: null,
    // 自定义头部高度
    totalHeaderHeightall: 0,
    // 有错题的学科列表
    errorSubjects: [],
    // 当前选中的学科索引
    selectedSubjectIndex: 0,
    // 当前选中的学科信息
    currentSubjectId: 0,
    currentSubjectName: '',
    // 有错题的章节列表
    errorChapters: [],
    // 加载状态
    loading: false,
    // 完整的科目列表（用于获取科目名称）
    allSubjects: [],
    // 完整的章节列表（用于获取章节名称）
    allChapters: {}
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad: function (options) {
    // 检查用户登录状态
    this.checkLoginStatus();
  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow: function () {
    // 如果用户已登录，刷新数据
    if (this.data.isLoggedIn) {
      this.loadErrorSubjects();
    }
  },

  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady: function () {
    // 获取自定义头部高度
    const query = wx.createSelectorQuery();
    query.select('#customHeader').boundingClientRect();
    query.exec((res) => {
      if (res && res[0]) {
        const headerHeight = res[0].height;
        this.setData({
          totalHeaderHeightall: headerHeight
        });
      }
    });
  },

  /**
   * 检查用户登录状态
   */
  checkLoginStatus: function () {
    const token = wx.getStorageSync('userToken');
    const userInfo = wx.getStorageSync('userInfo');

    if (token && userInfo) {
      this.setData({
        isLoggedIn: true,
        userInfo: userInfo
      });
      // 先加载完整的科目列表，然后再加载有错题的学科列表
      this.loadAllSubjects();
    }
  },

  /**
   * 加载完整的科目列表
   */
  loadAllSubjects: function () {
    app.api.getSubjectList().then(res => {
      if (res.data && res.data.length > 0) {
        this.setData({
          allSubjects: res.data
        });
      }
      // 无论是否成功获取科目列表，都继续加载错题列表
      this.loadErrorSubjects();
    }).catch(err => {
      console.error('获取完整科目列表失败:', err);
      // 失败时也继续加载错题列表
      this.loadErrorSubjects();
    });
  },

  /**
   * 根据科目ID获取科目名称
   */
  getSubjectNameById: function (subjectId) {
    const subject = this.data.allSubjects.find(s => s.id === subjectId);
    return subject ? subject.name : `科目${subjectId}`;
  },

  /**
   * 根据章节ID获取章节名称
   */
  getChapterNameById: function (chapterId, subjectId) {
    const chapters = this.data.allChapters[subjectId] || [];
    const chapter = chapters.find(c => c.id === chapterId);
    return chapter ? chapter.name : `章节${chapterId}`;
  },

  /**
   * 加载指定科目的完整章节列表
   */
  loadChaptersForSubject: function (subjectId) {
    // 避免重复加载
    if (this.data.allChapters[subjectId]) {
      return;
    }

    app.api.getChapterList({ subjectId: subjectId }).then(res => {
      if (res.data && res.data.length > 0) {
        const allChapters = { ...this.data.allChapters };
        allChapters[subjectId] = res.data;
        this.setData({
          allChapters: allChapters
        });

        // 如果当前正在显示该科目的章节列表，更新章节名称
        if (this.data.currentSubjectId === subjectId) {
          this.updateChapterNames(subjectId);
        }
      }
    }).catch(err => {
      console.error('获取章节列表失败:', err);
    });
  },

  /**
   * 更新章节列表中的章节名称
   */
  updateChapterNames: function (subjectId) {
    const chapters = this.data.errorChapters.map(chapter => ({
      ...chapter,
      name: this.getChapterNameById(chapter.id, subjectId)
    }));

    this.setData({
      errorChapters: chapters
    });
  },

  /**
   * 加载有错题的学科列表
   */
  loadErrorSubjects: function () {
    this.setData({ loading: true });

    // 调用getErrorBookList API，通过不指定subjectId和chapterId来获取用户所有错题
    // 然后从结果中提取出有错题的科目信息
    app.api.getErrorBookList().then(res => {
      if (res.code === 200 && res.data && res.data.list && res.data.list.length > 0) {
        // 从错题列表中提取所有不同的科目ID和名称
        const subjectMap = {};
        res.data.list.forEach(item => {
          if (item.question && item.question.subject_id) {
            const subjectId = item.question.subject_id;
            subjectMap[subjectId] = {
              id: subjectId,
              name: this.getSubjectNameById(subjectId)
            };
          }
        });

        // 转换为数组
        const errorSubjects = Object.values(subjectMap);

        this.setData({
          errorSubjects: errorSubjects
        });

        // 如果有科目，默认选中第一个并加载对应章节
        if (errorSubjects.length > 0) {
          this.setData({
            currentSubjectId: errorSubjects[0].id,
            currentSubjectName: errorSubjects[0].name
          });
          this.loadErrorChapters(errorSubjects[0].id);
        }
      }
      this.setData({ loading: false });
    }).catch(err => {
      console.error('获取学科列表失败:', err);
      this.setData({ loading: false });
    });
  },

  /**
   * 加载指定学科的错题章节列表
   */
  loadErrorChapters: function (subjectId) {
    this.setData({ loading: true });

    // 调用getErrorBookList API，指定subjectId参数获取该科目下的所有错题
    app.api.getErrorBookList({
      subjectId: subjectId,
      pageSize: 1000
    }).then(res => {
      if (res.code === 200 && res.data && res.data.list && res.data.list.length > 0) {
        // 从错题列表中提取章节信息并统计每个章节的错题数量
        const chapterMap = {};
        res.data.list.forEach(item => {
          if (item.question && item.question.chapter_id) {
            const chapterId = item.question.chapter_id;
            if (!chapterMap[chapterId]) {
              chapterMap[chapterId] = {
                id: chapterId,
                name: this.getChapterNameById(chapterId, subjectId),
                errorCount: 0
              };
            }
            chapterMap[chapterId].errorCount++;
          }
        });

        // 转换为数组并按章节ID排序
        const errorChapters = Object.values(chapterMap).sort((a, b) => a.id - b.id);

        this.setData({
          errorChapters: errorChapters
        });

        // 加载完整的章节列表以获取准确的章节名称
        this.loadChaptersForSubject(subjectId);
      } else {
        this.setData({
          errorChapters: []
        });
      }
      this.setData({ loading: false });
    }).catch(err => {
      console.error('获取章节列表失败:', err);
      this.setData({ loading: false });
    });
  },

  /**
   * 切换学科
   */
  onSubjectTap: function (e) {
    const index = e.currentTarget.dataset.index;
    const subject = this.data.errorSubjects[index];

    this.setData({
      selectedSubjectIndex: index,
      currentSubjectId: subject.id,
      currentSubjectName: subject.name
    });

    // 加载选中科目的错题章节列表
    this.loadErrorChapters(subject.id);
  },

  /**
   * 点击章节，跳转到章节错题列表
   */
  onChapterTap: function (e) {
    const chapterId = e.currentTarget.dataset.id;
    const subjectId = this.data.currentSubjectId;

    // 参数校验
    if (!chapterId || !subjectId) {
      console.error('缺少必要参数:', { chapterId, subjectId });
      wx.showToast({ title: '参数错误', icon: 'none' });
      return;
    }

    console.log('点击章节:', { chapterId, subjectId });

    // 只传递ID参数，科目名和章节名通过接口获取
    const url = `/pages/errorbook/chapterdetail/chapterdetail?chapterId=${chapterId}&subjectId=${subjectId}&isErrorBook=true`;

    wx.navigateTo({
      url: url,
      success: function () {
        console.log('成功跳转到错题列表页');
      },
      fail: function (error) {
        console.error('跳转失败:', error);
        wx.showToast({ title: '页面跳转失败', icon: 'none' });
      }
    });
  },

  /**
   * 跳转到登录页面
   */
  goToLogin: function () {
    wx.navigateTo({
      url: '/pages/logins/logins'
    });
  }
})